home *** CD-ROM | disk | FTP | other *** search
/ Freelog 22 / freelog 22.iso / Prog / Djgpp / GPC2952B.ZIP / info / gpc.i16 < prev    next >
Encoding:
GNU Info File  |  2001-02-09  |  49.1 KB  |  2,581 lines
  1. This is gpc.info, produced by makeinfo version 4.0 from gpc.texi.
  2.  
  3. INFO-DIR-SECTION GNU programming tools
  4. START-INFO-DIR-ENTRY
  5. * GPC: (gpc).                   The GNU Pascal Compiler.
  6. END-INFO-DIR-ENTRY
  7. INFO-DIR-SECTION Individual utilities
  8. START-INFO-DIR-ENTRY
  9. * GPC: (gpc)Invoking GPC.       The GNU Pascal Compiler.
  10. END-INFO-DIR-ENTRY
  11.  
  12.    This file documents the GNU Pascal Compiler.
  13.  
  14.    Copyright (C) 1988, 1996-2001 Free Software Foundation, Inc.
  15.  
  16.    Permission is granted to make and distribute verbatim copies of this
  17. manual provided the copyright notice and this permission notice are
  18. preserved on all copies.
  19.  
  20.    Permission is granted to copy and distribute modified versions of
  21. this manual under the conditions for verbatim copying, provided also
  22. that the sections entitled "GNU General Public License", "The GNU
  23. Project", "The GNU Manifesto" and "Funding for Free Software" are
  24. included exactly as in the original, and provided that the entire
  25. resulting derived work is distributed under the terms of a permission
  26. notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that the sections entitled "GNU General Public
  31. License", "The GNU Project", "The GNU Manifesto" and "Funding for Free
  32. Software" and this permission notice, may be included in translations
  33. approved by the Free Software Foundation instead of in the original
  34. English.
  35.  
  36. 
  37. File: gpc.info,  Node: ShortCard,  Next: ShortInt,  Prev: ShortBool,  Up: Reference
  38.  
  39. ShortCard
  40. =========
  41.  
  42. Synopsis
  43. --------
  44.  
  45.      type
  46.        ShortCard = Cardinal (BitSizeOf (ShortInt));
  47.  
  48. Description
  49. -----------
  50.  
  51.    `ShortCard' is an unsigned integer type which is not larger than
  52. `Cardinal'.  On most platforms it is 16 bits wide and thus has a range
  53. of `0..65535'.
  54.  
  55.    `ShortCard' in GNU Pascal is compatible to `short unsigned int' in
  56. GNU C.
  57.  
  58.    There are lots of other integer types in GPC, see *Note Integer
  59. Types::.
  60.  
  61. Conforming to
  62. -------------
  63.  
  64.    `ShortCard' is a GNU Pascal extension.
  65.  
  66. Example
  67. -------
  68.  
  69.      program ShortCardDemo;
  70.      var
  71.        a: ShortCard;
  72.      begin
  73.        a := 42;
  74.        WriteLn (a)
  75.      end.
  76.  
  77. See also
  78. --------
  79.  
  80.    *Note Integer Types::, *Note Subrange Types::.
  81.  
  82. 
  83. File: gpc.info,  Node: ShortInt,  Next: ShortReal,  Prev: ShortCard,  Up: Reference
  84.  
  85. ShortInt
  86. ========
  87.  
  88. Synopsis
  89. --------
  90.  
  91.      type
  92.        ShortInt  { built-in type }
  93.  
  94. Description
  95. -----------
  96.  
  97.    `ShortInt' is a signed integer type which is not larger than
  98. `Integer'.  On most platforms it is 16 bits wide and thus has a range
  99. of `-32768..32767'.
  100.  
  101.    `ShortInt' in GNU Pascal is compatible to `short int' in GNU C.
  102.  
  103.    There are lots of other integer types in GPC, see *Note Integer
  104. Types::.
  105.  
  106. Conforming to
  107. -------------
  108.  
  109.    `ShortInt' is a Borland Pascal extension. In Borland Pascal,
  110. `ShortInt' is an 8-bit signed integer type (`ByteInt' in GNU Pascal).
  111.  
  112. Example
  113. -------
  114.  
  115.      program ShortIntDemo;
  116.      var
  117.        a: ShortInt;
  118.      begin
  119.        a := 42;
  120.        WriteLn (a)
  121.      end.
  122.  
  123. See also
  124. --------
  125.  
  126.    *Note Integer Types::, *Note Subrange Types::.
  127.  
  128. 
  129. File: gpc.info,  Node: ShortReal,  Next: ShortWord,  Prev: ShortInt,  Up: Reference
  130.  
  131. ShortReal
  132. =========
  133.  
  134.    (Under construction.)
  135.  
  136. Synopsis
  137. --------
  138.  
  139.      type
  140.        ShortReal  { built-in type }
  141.  
  142. Description
  143. -----------
  144.  
  145. Conforming to
  146. -------------
  147.  
  148. Example
  149. -------
  150.  
  151.      program ShortRealDemo;
  152.      var
  153.        a: ShortReal;
  154.      begin
  155.        a := 42;
  156.        WriteLn (a)
  157.      end.
  158.  
  159. See also
  160. --------
  161.  
  162. 
  163. File: gpc.info,  Node: ShortWord,  Next: shr,  Prev: ShortReal,  Up: Reference
  164.  
  165. ShortWord
  166. =========
  167.  
  168. Synopsis
  169. --------
  170.  
  171.      type
  172.        ShortWord = ShortCard;
  173.  
  174. Description
  175. -----------
  176.  
  177.    `ShortWord' is an unsigned integer type which is not larger than
  178. `Word'.  On most platforms it is 16 bits wide and thus has a range of
  179. of `0..65535'.  It is the same as *Note ShortCard::.
  180.  
  181.    `ShortWord' in GNU Pascal is compatible to `short unsigned int' in
  182. GNU C.
  183.  
  184.    There are lots of other integer types in GPC, see *Note Integer
  185. Types::.
  186.  
  187. Conforming to
  188. -------------
  189.  
  190.    `ShortWord' is a GNU Pascal extension.
  191.  
  192.    `ShortWord' in GNU Pascal essentially corresponds to `Word' in
  193. Borland Pascal and Delphi where it is a 16-bit unsigned integer type.
  194.  
  195. Example
  196. -------
  197.  
  198.      program ShortWordDemo;
  199.      var
  200.        a: ShortWord;
  201.      begin
  202.        a := 42;
  203.        WriteLn (a)
  204.      end.
  205.  
  206. See also
  207. --------
  208.  
  209.    *Note Integer Types::, *Note Subrange Types::.
  210.  
  211. 
  212. File: gpc.info,  Node: shr,  Next: Sin,  Prev: ShortWord,  Up: Reference
  213.  
  214. shr
  215. ===
  216.  
  217. Synopsis
  218. --------
  219.  
  220.      operator shr (operand1, operand2: INTEGER TYPE) = Result: INTEGER TYPE;
  221.    or
  222.      procedure shr (var operand1: INTEGER TYPE; operand2: INTEGER TYPE);
  223.  
  224. Description
  225. -----------
  226.  
  227.    In GNU Pascal, `shr' has two built-in meanings:
  228.  
  229.   1. Bitwise shift right of an integer-type expression by another
  230.      integer value.  The result is of the type of the first operand.
  231.  
  232.   2. Use as a "procedure":  `operand1' is shifted right by `operand2';
  233.      the result is stored in `operand1'.
  234.  
  235.  
  236. Conforming to
  237. -------------
  238.  
  239.    `shr' is a Borland Pascal extension.
  240.  
  241.    Unlike the Borland compilers, GNU Pascal cares about the signedness
  242. of the first operand:  If a signed integer with a negative value is
  243. shifted right, "one" bits are filled in from the left.
  244.  
  245.    Use of `shr' as a "procedure" is a GNU Pascal extension.
  246.  
  247. Example
  248. -------
  249.  
  250.      program ShrDemo;
  251.      var
  252.        a: Integer;
  253.      begin
  254.        a := 1024 shr 4;  { yields 64 }
  255.        a := -127 shr 4;  { yields -8 }
  256.        shr (a, 2)  { same as `a := a shr 2' }
  257.      end.
  258.  
  259. See also
  260. --------
  261.  
  262.    *Note shl::, *Note Operators::.
  263.  
  264. 
  265. File: gpc.info,  Node: Sin,  Next: Single,  Prev: shr,  Up: Reference
  266.  
  267. Sin
  268. ===
  269.  
  270. Synopsis
  271. --------
  272.  
  273.      function Sin (x: Real): Real;
  274.    or
  275.      function Sin (z: Complex): Complex;
  276.  
  277. Description
  278. -----------
  279.  
  280.    `Sin' returns the sine of the argument.  The result is in the range
  281. `-1 <= Sin (x) <= 1' for real arguments.
  282.  
  283. Conforming to
  284. -------------
  285.  
  286.    The function `Sin' is defined in ISO-7185 Standard Pascal; its
  287. application to complex values is defined in ISO-10206 Extended Pascal.
  288.  
  289. Example
  290. -------
  291.  
  292.      program SinDemo;
  293.      begin
  294.        WriteLn (Sin (SqRt (2) / 2) : 0 : 5)
  295.        { yields 0.5 since Sin (SqRt (2) /2) = 0.5 }
  296.      end.
  297.  
  298. See also
  299. --------
  300.  
  301.    *Note ArcTan::, *Note Cos::, *Note Ln::, *Note Arg::.
  302.  
  303. 
  304. File: gpc.info,  Node: Single,  Next: SizeOf,  Prev: Sin,  Up: Reference
  305.  
  306. Single
  307. ======
  308.  
  309.    (Under construction.)
  310.  
  311. Synopsis
  312. --------
  313.  
  314.      type
  315.        Single = ShortReal;
  316.  
  317. Description
  318. -----------
  319.  
  320. Conforming to
  321. -------------
  322.  
  323. Example
  324. -------
  325.  
  326. See also
  327. --------
  328.  
  329. 
  330. File: gpc.info,  Node: SizeOf,  Next: SizeType,  Prev: Single,  Up: Reference
  331.  
  332. SizeOf
  333. ======
  334.  
  335. Synopsis
  336. --------
  337.  
  338.      function SizeOf (var x): SizeType;
  339.  
  340. Description
  341. -----------
  342.  
  343.    Returns the size of a type or variable in bytes.
  344.  
  345. Conforming to
  346. -------------
  347.  
  348.    `SizeOf' is a UCSD Pascal extension.
  349.  
  350. Example
  351. -------
  352.  
  353.      program SizeOfDemo;
  354.      var
  355.        a: Integer;
  356.        b: array [1 .. 8] of Char;
  357.      begin
  358.        WriteLn (SizeOf (a));  { Size of an `Integer'; often 4 bytes. }
  359.        WriteLn (SizeOf (b))   { Size of eight `Char's; usually 8 bytes. }
  360.      end.
  361.  
  362. See also
  363. --------
  364.  
  365.    *Note BitSizeOf::, *Note AlignOf::, *Note TypeOf::.
  366.  
  367. 
  368. File: gpc.info,  Node: SizeType,  Next: SmallInt,  Prev: SizeOf,  Up: Reference
  369.  
  370. SizeType
  371. ========
  372.  
  373.    (Under construction.)
  374.  
  375. Synopsis
  376. --------
  377.  
  378.      type
  379.        SizeType  { built-in type }
  380.  
  381. Description
  382. -----------
  383.  
  384. Conforming to
  385. -------------
  386.  
  387. Example
  388. -------
  389.  
  390.      program SizeTypeDemo;
  391.      var
  392.        a: array [1 .. 10] of Integer;
  393.        Size: SizeType;
  394.      begin
  395.        Size := SizeOf (a);
  396.        WriteLn (Size)
  397.      end.
  398.  
  399. See also
  400. --------
  401.  
  402. 
  403. File: gpc.info,  Node: SmallInt,  Next: Sqr,  Prev: SizeType,  Up: Reference
  404.  
  405. SmallInt
  406. ========
  407.  
  408. Synopsis
  409. --------
  410.  
  411.      type
  412.        SmallInt = ShortInt;
  413.  
  414. Description
  415. -----------
  416.  
  417.    `SmallInt' is a signed integer type which is not larger than
  418. `Integer'. On most platforms it is 16 bits wide and thus has a range of
  419. `-32768..32767'. It is the same as `ShortInt' (see *Note ShortInt::).
  420.  
  421.    There are lots of other integer types in GPC, see *Note Integer
  422. Types::.
  423.  
  424. Conforming to
  425. -------------
  426.  
  427.    `SmallInt' is a Delphi 2.0 extension.
  428.  
  429. Example
  430. -------
  431.  
  432.      program SmallIntDemo;
  433.      var
  434.        a: SmallInt;
  435.      begin
  436.        a := 42;
  437.        WriteLn (a)
  438.      end.
  439.  
  440. See also
  441. --------
  442.  
  443.    *Note ShortInt::, *Note Integer Types::, *Note Subrange Types::.
  444.  
  445. 
  446. File: gpc.info,  Node: Sqr,  Next: SqRt,  Prev: SmallInt,  Up: Reference
  447.  
  448. Sqr
  449. ===
  450.  
  451. Synopsis
  452. --------
  453.  
  454.      function Sqr (i: INTEGER TYPE): INTEGER TYPE;
  455.    or
  456.      function Sqr (x: REAL TYPE): REAL TYPE;
  457.    or
  458.      function Sqr (z: COMPLEX TYPE): COMPLEX TYPE;
  459.  
  460. Description
  461. -----------
  462.  
  463.    Returns the square of the argument:
  464.  
  465.      function Sqr (x: SOME TYPE): SOME TYPE;
  466.      begin
  467.        Sqr := x * x  { or: x pow 2 }
  468.      end;
  469.  
  470. Conforming to
  471. -------------
  472.  
  473.    The function `Sqr' is defined in ISO-7185 Standard Pascal; its
  474. application to complex values is defined in ISO-10206 Extended Pascal.
  475.  
  476. Example
  477. -------
  478.  
  479.      program SqrDemo;
  480.      
  481.      var
  482.        i: Complex;
  483.      
  484.      begin
  485.        i := Cmplx (0, 1);
  486.        WriteLn (Re (Sqr (i)) : 0 : 3)  { yields -1.000 }
  487.      end.
  488.  
  489. See also
  490. --------
  491.  
  492.    *Note pow::, *Note SqRt::, *Note Abs::, *Note Operators::.
  493.  
  494. 
  495. File: gpc.info,  Node: SqRt,  Next: StandardError,  Prev: Sqr,  Up: Reference
  496.  
  497. SqRt
  498. ====
  499.  
  500. Synopsis
  501. --------
  502.  
  503.      function SqRt (x: REAL TYPE): REAL TYPE;
  504.    or
  505.      function SqRt (z: COMPLEX TYPE): COMPLEX TYPE;
  506.  
  507. Description
  508. -----------
  509.  
  510.    Returns the positive square root of the argument.
  511.  
  512.    For real arguments, it is an error if the argument is negative.
  513.  
  514.    For complex arguments, `SqRt' returns the principal value of the
  515. root of the argument, i.e. the root with positive real part, or, if the
  516. real part is zero, that one with positive imaginary part.
  517.  
  518. Conforming to
  519. -------------
  520.  
  521.    The function `SqRt' is defined in ISO-7185 Standard Pascal; its
  522. application to complex values is defined in ISO-10206 Extended Pascal.
  523.  
  524. Example
  525. -------
  526.  
  527.      program SqRtDemo;
  528.      
  529.      var
  530.        m1: Complex;
  531.      
  532.      begin
  533.        m1 := Cmplx (-1, 0);  { -1 }
  534.        WriteLn (Re (SqRt (m1)) : 6 : 3, Im (SqRt (m1)) : 6 : 3);
  535.          { yields 1.000 -1.000, i.e. the imaginary unit, i }
  536.      end.
  537.  
  538. See also
  539. --------
  540.  
  541.    *Note pow::, *Note Sqr::, *Note Operators::.
  542.  
  543. 
  544. File: gpc.info,  Node: StandardError,  Next: StandardInput,  Prev: SqRt,  Up: Reference
  545.  
  546. StandardError
  547. =============
  548.  
  549.    (Under construction.)
  550.  
  551. Synopsis
  552. --------
  553.  
  554. Description
  555. -----------
  556.  
  557. Conforming to
  558. -------------
  559.  
  560. Example
  561. -------
  562.  
  563. See also
  564. --------
  565.  
  566. 
  567. File: gpc.info,  Node: StandardInput,  Next: StandardOutput,  Prev: StandardError,  Up: Reference
  568.  
  569. StandardInput
  570. =============
  571.  
  572.    (Under construction.)
  573.  
  574. Synopsis
  575. --------
  576.  
  577. Description
  578. -----------
  579.  
  580. Conforming to
  581. -------------
  582.  
  583. Example
  584. -------
  585.  
  586. See also
  587. --------
  588.  
  589. 
  590. File: gpc.info,  Node: StandardOutput,  Next: static,  Prev: StandardInput,  Up: Reference
  591.  
  592. StandardOutput
  593. ==============
  594.  
  595.    (Under construction.)
  596.  
  597. Synopsis
  598. --------
  599.  
  600. Description
  601. -----------
  602.  
  603. Conforming to
  604. -------------
  605.  
  606. Example
  607. -------
  608.  
  609. See also
  610. --------
  611.  
  612. 
  613. File: gpc.info,  Node: static,  Next: StdErr,  Prev: StandardOutput,  Up: Reference
  614.  
  615. static
  616. ======
  617.  
  618.    (Under construction.)
  619.  
  620. Synopsis
  621. --------
  622.  
  623. Description
  624. -----------
  625.  
  626. Conforming to
  627. -------------
  628.  
  629. Example
  630. -------
  631.  
  632. See also
  633. --------
  634.  
  635. 
  636. File: gpc.info,  Node: StdErr,  Next: Str,  Prev: static,  Up: Reference
  637.  
  638. StdErr
  639. ======
  640.  
  641. Synopsis
  642. --------
  643.  
  644.      var
  645.        StdErr: Text;
  646.  
  647. Description
  648. -----------
  649.  
  650.    The `StdErr' variable is connected to the standard error file
  651. handle. To report errors, you should prefer `WriteLn (StdErr,
  652. 'everything wrong')' over `WriteLn ('everything wrong')'.
  653.  
  654. Conforming to
  655. -------------
  656.  
  657.    `StdErr' is a GNU Pascal extension.
  658.  
  659. Example
  660. -------
  661.  
  662.      program StdErrDemo;
  663.      var
  664.        Denominator: Integer;
  665.      begin
  666.        ReadLn (Denominator);
  667.        if Denominator = 0 then
  668.          WriteLn (StdErr, ParamStr (0), ': division by zero')
  669.        else
  670.          WriteLn ('1 / ', Denominator, ' = ', 1 / Denominator)
  671.      end.
  672.  
  673. See also
  674. --------
  675.  
  676.    *Note StandardError::, *Note Output::, *Note Input::.
  677.  
  678. 
  679. File: gpc.info,  Node: Str,  Next: String,  Prev: StdErr,  Up: Reference
  680.  
  681. Str
  682. ===
  683.  
  684.    (Under construction.)
  685.  
  686. Synopsis
  687. --------
  688.  
  689.      procedure Str (x: INTEGER OR REAL; var Dest: String);
  690.    or
  691.      procedure Str (x: INTEGER OR REAL : FIELD WIDTH; var Dest: String);
  692.    or
  693.      procedure Str (x: Real : FIELD WIDTH : PRECISION; var Dest: String);
  694.    or
  695.      procedure Str (REPEATED CONSTRUCTS AS DESCRIBED ABOVE; var Dest: String);
  696.  
  697. Description
  698. -----------
  699.  
  700. Conforming to
  701. -------------
  702.  
  703.    `Str' is a UCSD Pascal extension, generalized by Borland Pascal.
  704. The possibility to handle more than one variable with one call to `Str'
  705. is a GNU Pascal extension.
  706.  
  707.    ISO-10206 Extended Pascal defines `WriteStr' instead of `Str'.
  708.  
  709. Example
  710. -------
  711.  
  712. See also
  713. --------
  714.  
  715.    *Note WriteStr::.
  716.  
  717. 
  718. File: gpc.info,  Node: String,  Next: String2CString,  Prev: Str,  Up: Reference
  719.  
  720. String
  721. ======
  722.  
  723.    (Under construction.)
  724.  
  725. Synopsis
  726. --------
  727.  
  728. Description
  729. -----------
  730.  
  731. Conforming to
  732. -------------
  733.  
  734. Example
  735. -------
  736.  
  737. See also
  738. --------
  739.  
  740. 
  741. File: gpc.info,  Node: String2CString,  Next: SubStr,  Prev: String,  Up: Reference
  742.  
  743. String2CString
  744. ==============
  745.  
  746.    (Under construction.)
  747.  
  748. Synopsis
  749. --------
  750.  
  751.      function String2CString (const S: String): CString;
  752.  
  753. Description
  754. -----------
  755.  
  756. Conforming to
  757. -------------
  758.  
  759. Example
  760. -------
  761.  
  762. See also
  763. --------
  764.  
  765. 
  766. File: gpc.info,  Node: SubStr,  Next: Succ,  Prev: String2CString,  Up: Reference
  767.  
  768. SubStr
  769. ======
  770.  
  771. Synopsis
  772. --------
  773.  
  774.      function SubStr (S: String; FirstChar: Integer): String;
  775.    or
  776.      function SubStr (S: String; FirstChar, Count: Integer): String;
  777.  
  778. Description
  779. -----------
  780.  
  781.    `SubStr' returns a sub-string of S starting with the character at
  782. position FIRSTCHAR.  If COUNT is given, such many characters will be
  783. copied into the sub-string.  If COUNT is omitted, the sub-string will
  784. will range to the end of S.
  785.  
  786.    If `Count' is too large for the sub-string to fit in S or if
  787. `FirstChar' exceeds the length of S, `SubStr' triggers a runtime error.
  788. (For a function returning the empty string instead, see *Note Copy::.)
  789.  
  790. Conforming to
  791. -------------
  792.  
  793.    `SubStr' is a ISO 10206 Extended Pascal extension.
  794.  
  795. Example
  796. -------
  797.  
  798.      program SubStrDemo;
  799.      var
  800.        S: String (42);
  801.      begin
  802.        S := 'Hello';
  803.        WriteLn (SubStr (S, 2, 3));   { yields "ell" }
  804.        WriteLn (SubStr (S, 3));      { yields "llo" }
  805.        WriteLn (SubStr (S, 4, 7));   { yields a runtime error }
  806.        WriteLn (SubStr (S, 42));     { yields a runtime error }
  807.      end.
  808.  
  809. See also
  810. --------
  811.  
  812.    *Note Copy::, String slice access.
  813.  
  814. 
  815. File: gpc.info,  Node: Succ,  Next: Text,  Prev: SubStr,  Up: Reference
  816.  
  817. Succ
  818. ====
  819.  
  820. Synopsis
  821. --------
  822.  
  823.      function Succ (i: ORDINAL TYPE): ORDINAL TYPE;
  824.    or
  825.      function Succ (i: ORDINAL TYPE; j: Integer): ORDINAL TYPE;
  826.  
  827.    or, with extended syntax (`--extended-syntax' or `{$X+}'),
  828.  
  829.      function Succ (p: POINTER TYPE): POINTER TYPE;
  830.    or
  831.      function Succ (p: POINTER TYPE; j: Integer): POINTER TYPE;
  832.  
  833. Description
  834. -----------
  835.  
  836.    Returns the successor of the ORDINAL TYPE value `i', or, if the
  837. second argument `j' is given, its `j'th successor.  For integer values
  838. `i', this is `i + 1' (or `i + j').  (No, `Succ' does _not_ work faster
  839. than plain addition.  Both are optimized to a single machine
  840. instruction or even expanded by the compiler, if possible.)
  841.  
  842.    If extended syntax is on, the argument may also be a pointer value.
  843. In this case, the address is incremented by the size of the variable
  844. pointed to, or, if `j' is given, by `j' times the size of the variable
  845. pointed to.  If `p' points to an element of an array, the returned
  846. pointer will point to the (`j'th) next element of the array.
  847.  
  848. Conforming to
  849. -------------
  850.  
  851.    The `Succ' function is defined in ISO-7185 Standard Pascal.  The
  852. optional second parameter is defined in ISO-10206 Extended Pascal.
  853. Application of `Succ' to pointers is defined in Borland Pascal.  The
  854. combination of the second argument with application to pointers is a
  855. GNU extension.
  856.  
  857. Example
  858. -------
  859.  
  860.      program SuccDemo;
  861.      
  862.      type
  863.        Metasyntactical = (foo, bar, baz);
  864.      
  865.      var
  866.        m: Metasyntactical;
  867.        c: Char;
  868.        a: array [1 .. 7] of Integer;
  869.        p: ^Integer;
  870.      
  871.      begin
  872.        m := Succ (foo);     { bar }
  873.        c := Succ ('A', 4);  { 'E' }
  874.        a [1] := 42;
  875.        a [2] := Succ (a [1]);     { 43 }
  876.        a [5] := Succ (a [2], 7);  { 50 }
  877.        {$X+}
  878.        p := @a [1];
  879.        p := Succ (p);     { points to `a [2]' now }
  880.        p := Succ (p, 3);  { points to `a [5]' now }
  881.      end.
  882.  
  883. See also
  884. --------
  885.  
  886.    *Note Pred::, *Note Inc::, *Note Pointer Arithmetics::.
  887.  
  888. 
  889. File: gpc.info,  Node: Text,  Next: TextWritable,  Prev: Succ,  Up: Reference
  890.  
  891. Text
  892. ====
  893.  
  894.    (Under construction.)
  895.  
  896. Synopsis
  897. --------
  898.  
  899.      type
  900.        Text  { built-in type }
  901.  
  902. Description
  903. -----------
  904.  
  905. Conforming to
  906. -------------
  907.  
  908. Example
  909. -------
  910.  
  911.      program TextDemo;
  912.      var
  913.        t: Text;
  914.      begin
  915.        Rewrite (t, 'hello.txt');
  916.        WriteLn (t, 'Hello, world!')
  917.      end.
  918.  
  919. See also
  920. --------
  921.  
  922. 
  923. File: gpc.info,  Node: TextWritable,  Next: then,  Prev: Text,  Up: Reference
  924.  
  925. TextWritable
  926. ============
  927.  
  928.    (Under construction.)
  929.  
  930. Synopsis
  931. --------
  932.  
  933. Description
  934. -----------
  935.  
  936. Conforming to
  937. -------------
  938.  
  939. Example
  940. -------
  941.  
  942. See also
  943. --------
  944.  
  945. 
  946. File: gpc.info,  Node: then,  Next: Time,  Prev: TextWritable,  Up: Reference
  947.  
  948. then
  949. ====
  950.  
  951.    (Under construction.)
  952.  
  953. Synopsis
  954. --------
  955.  
  956. Description
  957. -----------
  958.  
  959. Conforming to
  960. -------------
  961.  
  962. Example
  963. -------
  964.  
  965.      program ThenDemo;
  966.      var
  967.        i: Integer;
  968.      begin
  969.        Write ('Enter a number: ');
  970.        ReadLn (i);
  971.        if i > 42 then
  972.          WriteLn ('The number is greater than 42')
  973.      end.
  974.  
  975. See also
  976. --------
  977.  
  978. 
  979. File: gpc.info,  Node: Time,  Next: TimeStamp,  Prev: then,  Up: Reference
  980.  
  981. Time
  982. ====
  983.  
  984.    (Under construction.)
  985.  
  986. Synopsis
  987. --------
  988.  
  989.      function Time (T: TimeStamp): packed array [1 .. TIME LENGTH] of Char;
  990.  
  991. Description
  992. -----------
  993.  
  994. Conforming to
  995. -------------
  996.  
  997. Example
  998. -------
  999.  
  1000. See also
  1001. --------
  1002.  
  1003. 
  1004. File: gpc.info,  Node: TimeStamp,  Next: to,  Prev: Time,  Up: Reference
  1005.  
  1006. TimeStamp
  1007. =========
  1008.  
  1009.    (Under construction.)
  1010.  
  1011. Synopsis
  1012. --------
  1013.  
  1014.      type
  1015.        TimeStamp = {@@packed} record
  1016.          DateValid,
  1017.          TimeValid   : Boolean;
  1018.          Year        : Integer;
  1019.          Month       : 1 .. 12;
  1020.          Day         : 1 .. 31;
  1021.          DayOfWeek   : 0 .. 6;  { 0 means Sunday }
  1022.          Hour        : 0 .. 23;
  1023.          Minute      : 0 .. 59;
  1024.          Second      : 0 .. 61; { to allow for leap seconds }
  1025.          MicroSecond : 0 .. 999999
  1026.        end;
  1027.  
  1028.    (@@ Currently, in GPC, TimeStamp is not actually packed.)
  1029.  
  1030.    All fields except DayOfWeek and MicroSecond are required by Extended
  1031. Pascal.
  1032.  
  1033.    @@ `TimeStamp' may be later extended in GPC to contain the following
  1034. additional fields:
  1035.  
  1036.      Dst_used   : Boolean;  { If daylight savings are used }
  1037.      TimeZone   : Integer;  { Positive if west, in minutes }
  1038.      TimerValid : Boolean;  { Is the following timer valid }
  1039.      us_Timer   : Integer;  { A microsecond timer that is a 32 bit
  1040.                                modulus of the timer returned by the system. }
  1041.  
  1042.    Fields `Dst_used, TimeZone' and `DayOfWeek' will be valid when
  1043. `DateValid' is `True'. Field `us_Timer' will be valid when `TimerValid'
  1044. is `True'.
  1045.  
  1046. Description
  1047. -----------
  1048.  
  1049. Conforming to
  1050. -------------
  1051.  
  1052. Example
  1053. -------
  1054.  
  1055. See also
  1056. --------
  1057.  
  1058. 
  1059. File: gpc.info,  Node: to,  Next: to begin do,  Prev: TimeStamp,  Up: Reference
  1060.  
  1061. to
  1062. ==
  1063.  
  1064.    (Under construction.)
  1065.  
  1066. Synopsis
  1067. --------
  1068.  
  1069. Description
  1070. -----------
  1071.  
  1072. Conforming to
  1073. -------------
  1074.  
  1075. Example
  1076. -------
  1077.  
  1078. See also
  1079. --------
  1080.  
  1081. 
  1082. File: gpc.info,  Node: to begin do,  Next: to end do,  Prev: to,  Up: Reference
  1083.  
  1084. to begin do
  1085. ===========
  1086.  
  1087.    (Under construction.)
  1088.  
  1089. Synopsis
  1090. --------
  1091.  
  1092. Description
  1093. -----------
  1094.  
  1095. Conforming to
  1096. -------------
  1097.  
  1098. Example
  1099. -------
  1100.  
  1101. See also
  1102. --------
  1103.  
  1104. 
  1105. File: gpc.info,  Node: to end do,  Next: Trim,  Prev: to begin do,  Up: Reference
  1106.  
  1107. to end do
  1108. =========
  1109.  
  1110.    (Under construction.)
  1111.  
  1112. Synopsis
  1113. --------
  1114.  
  1115. Description
  1116. -----------
  1117.  
  1118. Conforming to
  1119. -------------
  1120.  
  1121. Example
  1122. -------
  1123.  
  1124. See also
  1125. --------
  1126.  
  1127. 
  1128. File: gpc.info,  Node: Trim,  Next: True,  Prev: to end do,  Up: Reference
  1129.  
  1130. Trim
  1131. ====
  1132.  
  1133.    (Under construction.)
  1134.  
  1135. Synopsis
  1136. --------
  1137.  
  1138.      function Trim (S: String): String;
  1139.  
  1140. Description
  1141. -----------
  1142.  
  1143. Conforming to
  1144. -------------
  1145.  
  1146. Example
  1147. -------
  1148.  
  1149. See also
  1150. --------
  1151.  
  1152. 
  1153. File: gpc.info,  Node: True,  Next: Trunc,  Prev: Trim,  Up: Reference
  1154.  
  1155. True
  1156. ====
  1157.  
  1158.    (Under construction.)
  1159.  
  1160. Synopsis
  1161. --------
  1162.  
  1163. Description
  1164. -----------
  1165.  
  1166. Conforming to
  1167. -------------
  1168.  
  1169. Example
  1170. -------
  1171.  
  1172. See also
  1173. --------
  1174.  
  1175. 
  1176. File: gpc.info,  Node: Trunc,  Next: Truncate,  Prev: True,  Up: Reference
  1177.  
  1178. Trunc
  1179. =====
  1180.  
  1181. Synopsis
  1182. --------
  1183.  
  1184.      function Trunc (x: Real): Integer;
  1185.  
  1186. Description
  1187. -----------
  1188.  
  1189.    `Trunc' converts `x' to the next integer below its argument (i.e.
  1190. truncates the numbers after the point).
  1191.  
  1192. Conforming to
  1193. -------------
  1194.  
  1195.    `Trunc' is defined in ISO-7185 Standard Pascal and supported by all
  1196. known Pascal variants.
  1197.  
  1198. Example
  1199. -------
  1200.  
  1201.      program TruncDemo;
  1202.      var
  1203.        Foo: Real;
  1204.      begin
  1205.        Foo := 9.876;
  1206.        WriteLn (Trunc (Foo))  { Prints 9 }
  1207.      end.
  1208.  
  1209. See also
  1210. --------
  1211.  
  1212.    *Note Round::.
  1213.  
  1214. 
  1215. File: gpc.info,  Node: Truncate,  Next: type,  Prev: Trunc,  Up: Reference
  1216.  
  1217. Truncate
  1218. ========
  1219.  
  1220.    (Under construction.)
  1221.  
  1222. Synopsis
  1223. --------
  1224.  
  1225.      procedure Truncate (var F: ANY FILE);
  1226.  
  1227. Description
  1228. -----------
  1229.  
  1230. Conforming to
  1231. -------------
  1232.  
  1233. Example
  1234. -------
  1235.  
  1236. See also
  1237. --------
  1238.  
  1239. 
  1240. File: gpc.info,  Node: type,  Next: type of,  Prev: Truncate,  Up: Reference
  1241.  
  1242. type
  1243. ====
  1244.  
  1245. Synopsis
  1246. --------
  1247.  
  1248.    As a type declaration:
  1249.      type
  1250.        TYPE INDENTIFIER = TYPE DEFINITION;
  1251.    or with initialization:
  1252.      type
  1253.        TYPE INDENTIFIER = TYPE DEFINITION value CONSTANT EXPRESSION;
  1254.  
  1255. Description
  1256. -----------
  1257.  
  1258.    The reserved word `type' starts the declaration of a TYPE IDENTIFIER
  1259. which is defined by TYPE DEFINITION.  For further description see *Note
  1260. Type Declaration::, *Note Type Declaration::, *Note Type Definition::,
  1261. *Note Data Types::.
  1262.  
  1263. Conforming to
  1264. -------------
  1265.  
  1266.    `type' is defined in ISO-7185 Standard Pascal and supported by all
  1267. known Pascal variants. Initializers are an ISO-10206 Extended Pascal
  1268. extension.
  1269.  
  1270. Example
  1271. -------
  1272.  
  1273.      program TypeDemo;
  1274.      type
  1275.        { This side is the }    { That side is the }
  1276.        { type declaration }    { type definition  }
  1277.      
  1278.        { array type }
  1279.        ArrayType                  = array [0 .. 9] of Integer;
  1280.      
  1281.        { record type }
  1282.        RecordType                 = record
  1283.                                       bar: Integer
  1284.                                     end;
  1285.      
  1286.        { subrange type }
  1287.        SubrangeType               = -123 .. 456;
  1288.      
  1289.        { enumeration type }
  1290.        EnumeratedType             = (Mon, Tue, Wed, Thu, Fri,  Sat, Sun);
  1291.      
  1292.        { set type }
  1293.        CharSetType                = set of Char;
  1294.      
  1295.        { object type }
  1296.        ObjectType                 = object
  1297.                                       constructor Init;
  1298.                                       procedure Method;
  1299.                                       destructor Done
  1300.                                     end;
  1301.      
  1302.        { pointer type to another type identifier }
  1303.        PArrayType                 = ^ArrayType;
  1304.      
  1305.        { an alias name for another type identifier }
  1306.        IntegerType                = Integer;
  1307.      
  1308.        { an integer which is initialized by 123 }
  1309.        InitializedInt             = Integer value 123;
  1310.      
  1311.        { a schema with discriminants x and y of type Integer }
  1312.        SchemaType (x, y: Integer) = array [x .. y] of Integer;
  1313.      
  1314.      begin
  1315.      end.
  1316.  
  1317. See also
  1318. --------
  1319.  
  1320.    *Note Type Declaration::, *Note Type Definition::, *Note Data
  1321. Types::, *Note Variable Declaration::, *Note array::, *Note record::,
  1322. *Note object::, *Note set::, *Note Pointer::, *Note value::.
  1323.  
  1324. 
  1325. File: gpc.info,  Node: type of,  Next: TypeOf,  Prev: type,  Up: Reference
  1326.  
  1327. type of
  1328. =======
  1329.  
  1330.    (Under construction.)
  1331.  
  1332. Synopsis
  1333. --------
  1334.  
  1335. Description
  1336. -----------
  1337.  
  1338. Conforming to
  1339. -------------
  1340.  
  1341. Example
  1342. -------
  1343.  
  1344. See also
  1345. --------
  1346.  
  1347. 
  1348. File: gpc.info,  Node: TypeOf,  Next: UnBind,  Prev: type of,  Up: Reference
  1349.  
  1350. TypeOf
  1351. ======
  1352.  
  1353. Synopsis
  1354. --------
  1355.  
  1356.      function TypeOf (var x): Pointer;
  1357.  
  1358. Description
  1359. -----------
  1360.  
  1361.    Returns a pointer to the VMT of an _object_ type or variable.  This
  1362. pointer can be used to identify the type of an object.
  1363.  
  1364. Conforming to
  1365. -------------
  1366.  
  1367.    ISO Pascal does not define `TypeOf', Borland Pascal does.
  1368.  
  1369. Example
  1370. -------
  1371.  
  1372.      program TypeOfDemo;
  1373.      type
  1374.        FooPtr = ^Foo;
  1375.        BarPtr = ^Bar;
  1376.      
  1377.        Foo = object        { Has a VMT, though it doesn't }
  1378.          x: Integer;       { contain virtual methods.     }
  1379.          constructor Init;
  1380.        end;
  1381.      
  1382.        Bar = object (Foo)
  1383.          y: Integer;
  1384.        end;
  1385.      
  1386.      constructor Foo.Init;
  1387.      begin
  1388.      end;
  1389.      
  1390.      var
  1391.        MyFoo: FooPtr;
  1392.      
  1393.      begin
  1394.        MyFoo := New (BarPtr, Init);
  1395.        if TypeOf (MyFoo^) = TypeOf (bar) then  { True }
  1396.          WriteLn ('OK')
  1397.      end.
  1398.  
  1399. See also
  1400. --------
  1401.  
  1402.    *Note BitSizeOf::, *Note AlignOf::, *Note TypeOf::, *Note SetType::,
  1403. *Note OOP::.
  1404.  
  1405. 
  1406. File: gpc.info,  Node: UnBind,  Next: unit,  Prev: TypeOf,  Up: Reference
  1407.  
  1408. UnBind
  1409. ======
  1410.  
  1411.    (Under construction.)
  1412.  
  1413. Synopsis
  1414. --------
  1415.  
  1416.      procedure UnBind (var F: ANY FILE);
  1417.  
  1418. Description
  1419. -----------
  1420.  
  1421. Conforming to
  1422. -------------
  1423.  
  1424. Example
  1425. -------
  1426.  
  1427. See also
  1428. --------
  1429.  
  1430. 
  1431. File: gpc.info,  Node: unit,  Next: Unpack,  Prev: UnBind,  Up: Reference
  1432.  
  1433. unit
  1434. ====
  1435.  
  1436.    (Under construction.)
  1437.  
  1438. Synopsis
  1439. --------
  1440.  
  1441. Description
  1442. -----------
  1443.  
  1444. Conforming to
  1445. -------------
  1446.  
  1447. Example
  1448. -------
  1449.  
  1450. See also
  1451. --------
  1452.  
  1453. 
  1454. File: gpc.info,  Node: Unpack,  Next: until,  Prev: unit,  Up: Reference
  1455.  
  1456. Unpack
  1457. ======
  1458.  
  1459.    (Under construction.)
  1460.  
  1461. Synopsis
  1462. --------
  1463.  
  1464.      procedure Unpack (Source: PACKED ARRAY;
  1465.                        var Dest: UNPACKED ARRAY;
  1466.                        FirstElement: INDEX TYPE);
  1467.  
  1468. Description
  1469. -----------
  1470.  
  1471. Conforming to
  1472. -------------
  1473.  
  1474. Example
  1475. -------
  1476.  
  1477. See also
  1478. --------
  1479.  
  1480. 
  1481. File: gpc.info,  Node: until,  Next: UpCase,  Prev: Unpack,  Up: Reference
  1482.  
  1483. until
  1484. =====
  1485.  
  1486.    (Under construction.)
  1487.  
  1488. Synopsis
  1489. --------
  1490.  
  1491. Description
  1492. -----------
  1493.  
  1494.    `until' is part of the `repeat ... until' loop statement.
  1495.  
  1496. Conforming to
  1497. -------------
  1498.  
  1499. Example
  1500. -------
  1501.  
  1502. See also
  1503. --------
  1504.  
  1505.    *Note repeat::, *Note while::, *Note for::.
  1506.  
  1507. 
  1508. File: gpc.info,  Node: UpCase,  Next: Update,  Prev: until,  Up: Reference
  1509.  
  1510. UpCase
  1511. ======
  1512.  
  1513.    (Under construction.)
  1514.  
  1515. Synopsis
  1516. --------
  1517.  
  1518.      function UpCase (Ch: Char): Char;
  1519.  
  1520. Description
  1521. -----------
  1522.  
  1523. Conforming to
  1524. -------------
  1525.  
  1526. Example
  1527. -------
  1528.  
  1529. See also
  1530. --------
  1531.  
  1532. 
  1533. File: gpc.info,  Node: Update,  Next: uses,  Prev: UpCase,  Up: Reference
  1534.  
  1535. Update
  1536. ======
  1537.  
  1538.    (Under construction.)
  1539.  
  1540. Synopsis
  1541. --------
  1542.  
  1543.      procedure Update (var F: ANY FILE);
  1544.  
  1545. Description
  1546. -----------
  1547.  
  1548. Conforming to
  1549. -------------
  1550.  
  1551. Example
  1552. -------
  1553.  
  1554. See also
  1555. --------
  1556.  
  1557. 
  1558. File: gpc.info,  Node: uses,  Next: Val,  Prev: Update,  Up: Reference
  1559.  
  1560. uses
  1561. ====
  1562.  
  1563. Synopsis
  1564. --------
  1565.  
  1566.    In a program:
  1567.  
  1568.      program @@fragment foo;
  1569.      
  1570.      uses
  1571.        bar1,
  1572.        bar2 in 'baz.pas',
  1573.        bar3;
  1574.      
  1575.      [...]
  1576.  
  1577.    In a unit:
  1578.  
  1579.      unit @@fragment Bar3;
  1580.      
  1581.      interface
  1582.      
  1583.      uses
  1584.        bar1,
  1585.        bar2 in 'baz.pas';
  1586.      
  1587.      [...]
  1588.      
  1589.      implementation
  1590.      
  1591.      uses
  1592.        bar3,
  1593.        bar4 in 'qux.pas';
  1594.      
  1595.      [...]
  1596.  
  1597. Description
  1598. -----------
  1599.  
  1600.    The reserved word `uses' in the _import part_ of a program or unit
  1601. makes the program or unit import an interface.
  1602.  
  1603.    The keyword `in' tells GPC to look for the `unit' in the specified
  1604. file; otherwise the file name is derived from the name of the interface
  1605. by adding first `.p', then `.pas'.
  1606.  
  1607.    There must be at most one import part in a program.
  1608.  
  1609.    In a unit, there can be one import part in the interface part and
  1610. one in the implementation part.
  1611.  
  1612.    The imported interface needn't be a UCSD/Borland Pascal unit, it may
  1613. be an interface exported by an Extended Pascal module as well.
  1614.  
  1615. Conforming to
  1616. -------------
  1617.  
  1618.    ISO Pascal does not define `uses' and units at all. UCSD and Borland
  1619. Pascal do, but without the `in' extension. Delphi supports `uses' like
  1620. described above.
  1621.  
  1622. Example
  1623. -------
  1624.  
  1625. See also
  1626. --------
  1627.  
  1628.    *Note unit::, *Note module::, *Note import::.
  1629.  
  1630. 
  1631. File: gpc.info,  Node: Val,  Next: value,  Prev: uses,  Up: Reference
  1632.  
  1633. Val
  1634. ===
  1635.  
  1636.    (Under construction.)
  1637.  
  1638. Synopsis
  1639. --------
  1640.  
  1641.      procedure Val (const Source: String; var x: INTEGER OR REAL);
  1642.    or
  1643.      procedure Val (const Source: String; var x: INTEGER OR REAL;
  1644.                     var ErrorCode: Integer);
  1645.  
  1646. Description
  1647. -----------
  1648.  
  1649. Conforming to
  1650. -------------
  1651.  
  1652. Example
  1653. -------
  1654.  
  1655. See also
  1656. --------
  1657.  
  1658. 
  1659. File: gpc.info,  Node: value,  Next: var,  Prev: Val,  Up: Reference
  1660.  
  1661. value
  1662. =====
  1663.  
  1664. Synopsis
  1665. --------
  1666.  
  1667. Description
  1668. -----------
  1669.  
  1670.    The reserved word `value' is part of a type or var declaration.  It
  1671. can be replaced by `:=' or `='.
  1672.  
  1673. Conforming to
  1674. -------------
  1675.  
  1676.    `value' is an ISO-10206 Extended Pascal extension. `:=' in this
  1677. context is a VAX Pascal extension, and `=' is a Borland Delphi
  1678. extension.
  1679.  
  1680. Example
  1681. -------
  1682.  
  1683. See also
  1684. --------
  1685.  
  1686.    *Note var::, *Note type::, *Note Variable Declaration::, *Note Type
  1687. Declaration::.
  1688.  
  1689. 
  1690. File: gpc.info,  Node: var,  Next: view,  Prev: value,  Up: Reference
  1691.  
  1692. var
  1693. ===
  1694.  
  1695. Synopsis
  1696. --------
  1697.  
  1698.    As part of a variable declaration part:
  1699.      var VARIABLE IDENTIFIER: TYPE IDENTIFIER;
  1700.    or
  1701.      var VARIABLE IDENTIFIER: TYPE DEFINITION;
  1702.    and with initializing value:
  1703.      var VARIABLE IDENTIFIER: TYPE IDENTIFIER value CONSTANT EXPRESSION;
  1704.    or
  1705.      var VARIABLE IDENTIFIER: TYPE DEFINITION value CONSTANT EXPRESSION;
  1706.  
  1707. As part of a parameter list:
  1708.      var VAR PARAMETER;
  1709.    or with type declaration
  1710.      var VAR PARAMETER: TYPE IDENTIFIER;
  1711.  
  1712. or with forced passing by reference:
  1713.      protected var VAR PARAMETER;
  1714.    or with type declaration
  1715.      protected var VAR PARAMETER: TYPE IDENTIFIER;
  1716.  
  1717. Description
  1718. -----------
  1719.  
  1720.    In a declaration part: The reserved word `var' declares a VARIABLE
  1721. IDENTIFIER whose type is of TYPE IDENTIFIER or which is defined by TYPE
  1722. DEFINITION.  For further description see *Note Variable Declaration::,
  1723. *Note Type Declaration::, *Note Type Definition::, *Note Data Types::.
  1724.  
  1725.    In a parameter list: see *Note Subroutine Parameter List
  1726. Declaration::.
  1727.  
  1728. Conforming to
  1729. -------------
  1730.  
  1731.    `var' is defined in ISO-7185 Standard Pascal and supported by all
  1732. known Pascal variants. Untyped `var' parameters in parameter lists are
  1733. a UCSD Pascal extension.
  1734.  
  1735. Example
  1736. -------
  1737.  
  1738.      program VarDemo;
  1739.      
  1740.      type
  1741.        FooType = Integer;
  1742.      
  1743.      var
  1744.        Bar: FooType;
  1745.        ArrayFoo: array [0 .. 9] of Integer;   { array var definition }
  1746.        FecordFoo: record                      { record var definition }
  1747.                     bar : Integer
  1748.                   end;
  1749.        CharsetFoo: set of Char;               { set var }
  1750.        SubrangeFoo: -123 .. 456;              { subrange var }
  1751.        EnumeratedFoo: (Mon, Tue, Wed, Thu, Fri, Sat, Sun);  {enumerated var }
  1752.        PointerBar: ^FooType;                  { pointer var }
  1753.      
  1754.      procedure ReadFoo (var foo: FooType);
  1755.      begin
  1756.        ReadLn (foo)
  1757.      end;
  1758.      
  1759.      begin
  1760.      end.
  1761.  
  1762. See also
  1763. --------
  1764.  
  1765.    *Note type::, *Note array::, *Note record::, *Note set::, *Note
  1766. Subrange Types::, *Note Pointer::, *Note protected::.
  1767.  
  1768. 
  1769. File: gpc.info,  Node: view,  Next: virtual,  Prev: var,  Up: Reference
  1770.  
  1771. view
  1772. ====
  1773.  
  1774.    Not yet implemented.
  1775.  
  1776. Synopsis
  1777. --------
  1778.  
  1779. Description
  1780. -----------
  1781.  
  1782. Conforming to
  1783. -------------
  1784.  
  1785. Example
  1786. -------
  1787.  
  1788. See also
  1789. --------
  1790.  
  1791. 
  1792. File: gpc.info,  Node: virtual,  Next: Void,  Prev: view,  Up: Reference
  1793.  
  1794. virtual
  1795. =======
  1796.  
  1797.    (Under construction.)
  1798.  
  1799. Synopsis
  1800. --------
  1801.  
  1802. Description
  1803. -----------
  1804.  
  1805. Conforming to
  1806. -------------
  1807.  
  1808. Example
  1809. -------
  1810.  
  1811. See also
  1812. --------
  1813.  
  1814. 
  1815. File: gpc.info,  Node: Void,  Next: volatile,  Prev: virtual,  Up: Reference
  1816.  
  1817. Void
  1818. ====
  1819.  
  1820.    (Under construction.)
  1821.  
  1822. Synopsis
  1823. --------
  1824.  
  1825.      type
  1826.        Void  { built-in type }
  1827.  
  1828. Description
  1829. -----------
  1830.  
  1831. Conforming to
  1832. -------------
  1833.  
  1834. Example
  1835. -------
  1836.  
  1837.      program VoidDemo;
  1838.      
  1839.      procedure p (var x : Void);
  1840.      begin
  1841.      end;
  1842.      
  1843.      var
  1844.        i: Integer;
  1845.        s: String (42);
  1846.      
  1847.      begin
  1848.        p (i);
  1849.        p (s)
  1850.      end.
  1851.  
  1852. See also
  1853. --------
  1854.  
  1855. 
  1856. File: gpc.info,  Node: volatile,  Next: while,  Prev: Void,  Up: Reference
  1857.  
  1858. volatile
  1859. ========
  1860.  
  1861.    (Under construction.)
  1862.  
  1863. Synopsis
  1864. --------
  1865.  
  1866. Description
  1867. -----------
  1868.  
  1869. Conforming to
  1870. -------------
  1871.  
  1872. Example
  1873. -------
  1874.  
  1875. See also
  1876. --------
  1877.  
  1878. 
  1879. File: gpc.info,  Node: while,  Next: with,  Prev: volatile,  Up: Reference
  1880.  
  1881. while
  1882. =====
  1883.  
  1884. Synopsis
  1885. --------
  1886.  
  1887.      while BOOLEAN EXPRESSION do
  1888.        STATEMENT
  1889.  
  1890. Description
  1891. -----------
  1892.  
  1893.    The `while' statement declares a loop. For further description see
  1894. *Note while Statement::.
  1895.  
  1896. Conforming to
  1897. -------------
  1898.  
  1899.    `while' is defined in ISO-7185 Standard Pascal and supported by all
  1900. known Pascal variants.
  1901.  
  1902. Example
  1903. -------
  1904.  
  1905.      program WhileDemo;
  1906.      var
  1907.        Foo, Bar: Integer;
  1908.      begin
  1909.        WriteLn ('Enter an descending series of integer numbers.');
  1910.        WriteLn ('Terminate by breaking this rule.');
  1911.        WriteLn ('Enter start number: ');
  1912.        Bar := MaxInt;
  1913.        ReadLn (Foo);
  1914.        while Foo < Bar do
  1915.          begin
  1916.            Bar := Foo;
  1917.            ReadLn (Foo)
  1918.          end;
  1919.        WriteLn ('The last number of your series was: ', Bar)
  1920.      end.
  1921.  
  1922. See also
  1923. --------
  1924.  
  1925.    *Note repeat Statement::, *Note for Statement::
  1926.  
  1927. 
  1928. File: gpc.info,  Node: with,  Next: Word,  Prev: while,  Up: Reference
  1929.  
  1930. with
  1931. ====
  1932.  
  1933.    (Under construction.)
  1934.  
  1935. Synopsis
  1936. --------
  1937.  
  1938. Description
  1939. -----------
  1940.  
  1941.    _Note_: `with' statement overwrites program namespace.
  1942.  
  1943. Conforming to
  1944. -------------
  1945.  
  1946. Example
  1947. -------
  1948.  
  1949.    ...
  1950.  
  1951.    { Note bar is overwritten by foo.bar }  ...
  1952.  
  1953. See also
  1954. --------
  1955.  
  1956. 
  1957. File: gpc.info,  Node: Word,  Next: WordBool,  Prev: with,  Up: Reference
  1958.  
  1959. Word
  1960. ====
  1961.  
  1962. Synopsis
  1963. --------
  1964.  
  1965.      type
  1966.        Word = Cardinal;
  1967.    or
  1968.      type
  1969.        Word (n) = Cardinal (n);
  1970.  
  1971. Description
  1972. -----------
  1973.  
  1974.    `Word' is the "natural" unsigned integer type in GNU Pascal.  On
  1975. most platforms it is 32 bits wide and thus has a range of
  1976. `0..4294967295'.  It is the same as *Note Cardinal::, introduced for
  1977. compatibility with other Pascal compilers.
  1978.  
  1979.    As an extension, GPC allows to use `Word' as a pseudo-schema to
  1980. produce types with a specified size in bits; for example
  1981.  
  1982.      type
  1983.        Word16 = Cardinal (16);
  1984.  
  1985.    defines an unsigned integer type with 16 bits.  The same mechanism
  1986. works for `Cardinal' and `Integer', too.
  1987.  
  1988.    `Word' in GNU Pascal is compatible to `unsigned int' in GNU C.
  1989.  
  1990.    There are lots of other integer types in GPC, see *Note Integer
  1991. Types::.
  1992.  
  1993. Conforming to
  1994. -------------
  1995.  
  1996.    ISO Pascal does not define `Cardinal'.  (However see *Note Subrange
  1997. Types::.)
  1998.  
  1999.    The `Word' type appears in Borland Pascal and Delphi, too, where it
  2000. is a 16-bit unsigned integer type.
  2001.  
  2002. Example
  2003. -------
  2004.  
  2005.      program WordDemo;
  2006.      var
  2007.        a: Word;
  2008.      begin
  2009.        a := 42;
  2010.        WriteLn (a)
  2011.      end.
  2012.  
  2013. See also
  2014. --------
  2015.  
  2016.    *Note Integer Types::, *Note Subrange Types::.
  2017.  
  2018. 
  2019. File: gpc.info,  Node: WordBool,  Next: Write,  Prev: Word,  Up: Reference
  2020.  
  2021. WordBool
  2022. ========
  2023.  
  2024.    (Under construction.)
  2025.  
  2026. Synopsis
  2027. --------
  2028.  
  2029.      type
  2030.        WordBool = Boolean (BitSizeOf (Word));
  2031.  
  2032. Description
  2033. -----------
  2034.  
  2035. Conforming to
  2036. -------------
  2037.  
  2038. Example
  2039. -------
  2040.  
  2041.      program WordBoolDemo;
  2042.      var
  2043.        a: WordBool;
  2044.      begin
  2045.        Word (a) := 1;
  2046.        if a then WriteLn ('Ord (True) = 1')
  2047.      end.
  2048.  
  2049. See also
  2050. --------
  2051.  
  2052. 
  2053. File: gpc.info,  Node: Write,  Next: WriteLn,  Prev: WordBool,  Up: Reference
  2054.  
  2055. Write
  2056. =====
  2057.  
  2058.    (Under construction.)
  2059.  
  2060. Synopsis
  2061. --------
  2062.  
  2063.      procedure Write (var F: TYPED FILE; VARIABLE);
  2064.    or
  2065.      procedure Write (var F: Text; VALUES AND FORMAT SPECIFICATIONS);
  2066.    or
  2067.      procedure Write (VALUES AND FORMAT SPECIFICATIONS);
  2068.  
  2069. Description
  2070. -----------
  2071.  
  2072. Conforming to
  2073. -------------
  2074.  
  2075. Example
  2076. -------
  2077.  
  2078. See also
  2079. --------
  2080.  
  2081. 
  2082. File: gpc.info,  Node: WriteLn,  Next: WriteStr,  Prev: Write,  Up: Reference
  2083.  
  2084. WriteLn
  2085. =======
  2086.  
  2087.    (Under construction.)
  2088.  
  2089. Synopsis
  2090. --------
  2091.  
  2092.      procedure WriteLn (var F: Text; VALUES AND FORMAT SPECIFICATIONS);
  2093.    or
  2094.      procedure WriteLn (VALUES AND FORMAT SPECIFICATIONS);
  2095.  
  2096. Description
  2097. -----------
  2098.  
  2099. Conforming to
  2100. -------------
  2101.  
  2102. Example
  2103. -------
  2104.  
  2105. See also
  2106. --------
  2107.  
  2108. 
  2109. File: gpc.info,  Node: WriteStr,  Next: xor,  Prev: WriteLn,  Up: Reference
  2110.  
  2111. WriteStr
  2112. ========
  2113.  
  2114.    (Under construction.)
  2115.  
  2116. Synopsis
  2117. --------
  2118.  
  2119.      procedure WriteStr (var Dest: String; VALUES AND FORMAT SPECIFICATIONS);
  2120.  
  2121. Description
  2122. -----------
  2123.  
  2124. Conforming to
  2125. -------------
  2126.  
  2127. Example
  2128. -------
  2129.  
  2130. See also
  2131. --------
  2132.  
  2133. 
  2134. File: gpc.info,  Node: xor,  Prev: WriteStr,  Up: Reference
  2135.  
  2136. xor
  2137. ===
  2138.  
  2139. Synopsis
  2140. --------
  2141.  
  2142.      operator xor (operand1, operand2: Boolean) = Result: Boolean;
  2143.    or
  2144.      operator xor (operand1, operand2: INTEGER TYPE) = Result: INTEGER TYPE;
  2145.    or
  2146.      procedure xor (var operand1: INTEGER TYPE; operand2: INTEGER TYPE);
  2147.  
  2148. Description
  2149. -----------
  2150.  
  2151.    In GNU Pascal, `xor' has three built-in meanings:
  2152.  
  2153.   1. Logical "exclusive or" between two `Boolean'-type expressions.
  2154.      The result of the operation is of `Boolean' type.  (Logical `foo
  2155.      xor bar' in fact has the same effect as `foo <> bar'.)
  2156.  
  2157.   2. Bitwise "exclusive or" between two integer-type expressions.  The
  2158.      result is of the common integer type of both expressions.
  2159.  
  2160.   3. Use as a "procedure":  `operand1' is "xor"ed bitwise with
  2161.      `operand2'; the result is stored in `operand1'.
  2162.  
  2163.  
  2164. Conforming to
  2165. -------------
  2166.  
  2167.    ISO Pascal does not define the `xor' operator; Borland Pascal and
  2168. Delphi do.
  2169.  
  2170.    Use of `xor' as a "procedure" is a GNU extension.
  2171.  
  2172. Example
  2173. -------
  2174.  
  2175.      program XorDemo;
  2176.      var
  2177.        a, b, c: Integer;
  2178.      begin
  2179.        if (a = 0) xor (b = 0) then
  2180.          c := 1  { happens if either `a' or `b' is zero,    }
  2181.                  { but not if both are zero or both nonzero }
  2182.        else if a xor b = 0 then  { bitwise xor }
  2183.          c := 2  { happens if a = b }
  2184.        else
  2185.          xor (c, a)  { same as `c := c xor a' }
  2186.      end.
  2187.  
  2188. See also
  2189. --------
  2190.  
  2191.    *Note and::, *Note or::, *Note Operators::.
  2192.  
  2193. 
  2194. File: gpc.info,  Node: Keywords,  Next: Support,  Prev: Reference,  Up: Top
  2195.  
  2196. Pascal keywords and operators supported by GNU Pascal.
  2197. ******************************************************
  2198.  
  2199.    This chapter lists all keywords understood by GNU Pascal.
  2200.  
  2201.    By default, keywords can be redefined to make it possible that every
  2202. correct ISO 7185 program can be compiled. However, you can use the
  2203. compiler dialect switches (e.g., `--extended-pascal' or
  2204. `--borland-pascal') to tell GPC that keywords of a given standard must
  2205. not be redefined.
  2206.  
  2207.    The keywords are taken from the following standards:
  2208.  
  2209.    * ISO 7185 Standard Pascal (SP)
  2210.  
  2211.    * ISO 10206 Extended Pascal (EP)
  2212.  
  2213.    * ANSI draft Object Pascal (OP)
  2214.  
  2215.    * USCD Pascal (USCD)
  2216.  
  2217.    * Borland Pascal 7.0 (BP)
  2218.  
  2219.    * Borland Delphi (BD)
  2220.  
  2221.    * Pascal-SC (PXSC, Pascal eXtensions for Scientific Calculations)
  2222.  
  2223.    * VAX Pascal (VP)
  2224.  
  2225.    * GNU Pascal extensions (GPC)
  2226.  
  2227.    In GPC you are free to re-define everything that is not a reserved
  2228. word in ISO 7185 Pascal in your program or the dialect selected.  E.g.,
  2229. you do not have to modify your code for GPC if you have an identifier
  2230. like `Restricted' or `Value' or some such, unless you compile with the
  2231. `--extended-pascal' option.
  2232.  
  2233.    The following table lists all known keywords with short
  2234. descriptions. The links point to the longer descriptions in the
  2235. reference.
  2236.  
  2237. absolute (BP, BD, GPC) (*note absolute::)
  2238.      overloaded variable declaration
  2239.  
  2240. abstract (OP, GPC) (*note abstract::)
  2241.      abstract object type declaration (not yet implemented)
  2242.  
  2243. all (GPC) (*note all::)
  2244.      `export' (*note export::) extension (`export foo = all')
  2245.  
  2246. and (any) (*note and::)
  2247.      Boolean or bitwise `and' operator or part of the `and then' (*note
  2248.      and then::) operator
  2249.  
  2250. and_then (EP, OP, GPC) (*note and_then::)
  2251.      short-circuit Boolean `and' (*note and::) operator
  2252.  
  2253. array (any) (*note array::)
  2254.      array type declaration
  2255.  
  2256. asm (BP, BD, GPC) (*note asm::)
  2257.      GNU style inline assembler code
  2258.  
  2259. asmname (GPC) (*note asmname::)
  2260.      linker name of routines and variables
  2261.  
  2262. attribute (GPC) (*note attribute::)
  2263.      attributes of routines and variables
  2264.  
  2265. begin (any) (*note begin::)
  2266.      begin of a code block, part of a `to begin do' (*note to begin
  2267.      do::) module constructor
  2268.  
  2269. bindable (EP, OP, GPC) (*note bindable::)
  2270.      external binding of files
  2271.  
  2272. case (any) (*note case::)
  2273.      multi-branch conditional statement or variant record type
  2274.  
  2275. class (OP, BD, GPC) (*note class::)
  2276.      OOE/Delphi style object classes (not yet implemented)
  2277.  
  2278. const (any) (*note const::)
  2279.      constant declaration or constant parameter declaration
  2280.  
  2281. constructor (OP, BP, BD, GPC) (*note constructor::)
  2282.      object constructor
  2283.  
  2284. destructor (OP, BP, BD, GPC) (*note destructor::)
  2285.      object destructor
  2286.  
  2287. div (any) (*note div::)
  2288.      integer or real division operator
  2289.  
  2290. do (any) (*note do::)
  2291.      part of a `while' (*note while::) or `for' (*note for::) loop, a
  2292.      `with' (*note with::) statement, or a `to begin do' (*note to
  2293.      begin do::) or `to end do' (*note to end do::) module constructor
  2294.      or destructor
  2295.  
  2296. downto (any) (*note downto::)
  2297.      part of a `for' (*note for::) loop when counting downwards
  2298.  
  2299. else (any) (*note else::)
  2300.      alternative part of an `if' (*note if::) statement, default case
  2301.      label or part of the `or else' (*note or else::) operator
  2302.  
  2303. end (any) (*note end::)
  2304.      end of a code block, end of a `case' (*note case::) statement, end
  2305.      of a record or object declaration, part of a `to end do' (*note to
  2306.      end do::) module destructor
  2307.  
  2308. export (EP, OP, BP, BD, GPC) (*note export::)
  2309.      module interface export
  2310.  
  2311. exports (BP, BD, GPC) (*note exports::)
  2312.      library export (not yet implemented)
  2313.  
  2314. external (EP, OP, UCSD, BP, BD, GPC) (*note external::)
  2315.      declaration of external objects
  2316.  
  2317. file (any) (*note file::)
  2318.      non-text file type declaration
  2319.  
  2320. for (any) (*note for::)
  2321.      loop statement where the number of loops is known in advance
  2322.  
  2323. forward (UCSD, BP, BD, GPC) (*note forward::)
  2324.      declaration of a routine whose definition follows below
  2325.  
  2326. function (any) (*note function::)
  2327.      function declaration
  2328.  
  2329. goto (any) (*note goto::)
  2330.      statement to jump to a `label' (*note label::)
  2331.  
  2332. if (any) (*note if::)
  2333.      conditional statement
  2334.  
  2335. import (EP, OP, GPC) (*note import::)
  2336.      module interface import
  2337.  
  2338. implementation (EP, OP, UCSD, BP, BD, GPC) (*note implementation::)
  2339.      module or unit implementation part
  2340.  
  2341. in (any) (*note in::)
  2342.      set membership test or part of a `for' (*note for::) loop when
  2343.      iterating through sets
  2344.  
  2345. inherited (OP, BP, BD, GPC) (*note inherited::)
  2346.      reference to methods of ancestor object types
  2347.  
  2348. inline (GPC) (*note inline::)
  2349.      declaration of inline routines
  2350.  
  2351. interface (EP, OP, UCSD, BP, BD, GPC) (*note interface::)
  2352.      module or unit interface part
  2353.  
  2354. interrupt (BP, BD) (*note interrupt::)
  2355.      interrupt handler declaration (not yet implemented)
  2356.  
  2357. is (OP, BD, GPC) (*note is::)
  2358.      object type membership test (not yet implemented)
  2359.  
  2360. label (any) (*note label::)
  2361.      label declaration for a `goto' (*note goto::) statement
  2362.  
  2363. library (BP, BD, GPC) (*note library::)
  2364.      library declaration (not yet implemented)
  2365.  
  2366. mod (any) (*note mod::)
  2367.      integer remainder operator
  2368.  
  2369. module (EP, OP, GPC) (*note module::)
  2370.      EP style or PXSC style (only partially implemented) modules
  2371.  
  2372. nil (any) (*note nil::)
  2373.      reserved value for unassigned pointers
  2374.  
  2375. not (any) (*note not::)
  2376.      Boolean or bitwise `not' operator
  2377.  
  2378. object (BP, BD, GPC) (*note object::)
  2379.      BP style object declaration
  2380.  
  2381. of (any) (*note of::)
  2382.      part of an array, set or typed file type declaration, a `case'
  2383.      (*note case::) statement, a variant record type or a `type of'
  2384.      (*note type of::) type inquiry
  2385.  
  2386. only (EP, OP, GPC) (*note only::)
  2387.      import specification
  2388.  
  2389. operator (PXSC, GPC) (*note operator::)
  2390.      operator declaration
  2391.  
  2392. or (any) (*note or::)
  2393.      Boolean or bitwise `or' operator or part of the `or else' (*note
  2394.      or else::) operator
  2395.  
  2396. or_else (EP, OP, GPC) (*note or_else::)
  2397.      short-circuit Boolean `or' (*note or::) operator
  2398.  
  2399. otherwise (EP, OP, GPC) (*note otherwise::)
  2400.      default case label
  2401.  
  2402. packed (any) (*note packed::)
  2403.      declaration of packed record or array types, also packed ordinal
  2404.      subranges
  2405.  
  2406. pow (EP, OP, GPC) (*note pow::)
  2407.      exponentiation operator with integer exponent
  2408.  
  2409. private (BP, BD, GPC) (*note private::)
  2410.      private object fields
  2411.  
  2412. procedure (any) (*note procedure::)
  2413.      procedure declaration
  2414.  
  2415. program (any) (*note program::)
  2416.      start of a Pascal program
  2417.  
  2418. property (OP, BD, GPC) (*note property::)
  2419.      variable properties (not yet implemented)
  2420.  
  2421. protected (EP, OP, BD, GPC) (*note protected::)
  2422.      read-only formal parameters and protected object fields
  2423.  
  2424. public (BP, BD, GPC) (*note public::)
  2425.      public object fields
  2426.  
  2427. published (BP, BD, GPC) (*note published::)
  2428.      published object fields
  2429.  
  2430. qualified (EP, OP, GPC) (*note qualified::)
  2431.      import specification
  2432.  
  2433. record (any) (*note record::)
  2434.      structured type declaration
  2435.  
  2436. repeat (any) (*note repeat::)
  2437.      loop statement
  2438.  
  2439. resident (BP, BD) (*note resident::)
  2440.      library export specification (not yet implemented)
  2441.  
  2442. restricted (EP, OP, GPC) (*note restricted::)
  2443.      type specification
  2444.  
  2445. segment (UCSD) (*note segment::)
  2446.      segment specification (not yet implemented)
  2447.  
  2448. set (any) (*note set::)
  2449.      set type declaration
  2450.  
  2451. shl (BP, BD, GPC) (*note shl::)
  2452.      bitwise left shift operator
  2453.  
  2454. shr (BP, BD, GPC) (*note shr::)
  2455.      bitwise right shift operator
  2456.  
  2457. static (GPC) (*note static::)
  2458.      static variable declaration
  2459.  
  2460. then (any) (*note then::)
  2461.      part of an `if' (*note if::) statement or part of the `and then'
  2462.      (*note and then::) operator
  2463.  
  2464. to (any) (*note to::)
  2465.      part of a `for' (*note for::) loop when counting upwards or a `to
  2466.      begin do' (*note to begin do::) or `to end do' (*note to end do::)
  2467.      module constructor or destructor
  2468.  
  2469. type (any) (*note type::)
  2470.      type declaration or part of a `type of' (*note type of::) type
  2471.      inquiry
  2472.  
  2473. unit (UCSD, BP, BD, GPC) (*note unit::)
  2474.      UCSD and BP style unit declaration
  2475.  
  2476. until (any) (*note until::)
  2477.      end of a `repeat' (*note repeat::) statement
  2478.  
  2479. uses (UCSD, BP, BD, GPC) (*note uses::)
  2480.      unit import
  2481.  
  2482. value (EP, OP, GPC) (*note value::)
  2483.      variable initializer
  2484.  
  2485. var (any) (*note var::)
  2486.      variable declaration or reference parameter declaration
  2487.  
  2488. view (OP, GPC) (*note view::)
  2489.      object class view (not yet implemented)
  2490.  
  2491. virtual (OP, BP, BD, GPC) (*note virtual::)
  2492.      virtual object method declaration
  2493.  
  2494. volatile (GPC) (*note volatile::)
  2495.      volatile variable declaration
  2496.  
  2497. while (any) (*note while::)
  2498.      loop statement
  2499.  
  2500. with (any) (*note with::)
  2501.      automatic record or object field access
  2502.  
  2503. xor (BP, BD, GPC) (*note xor::)
  2504.      Boolean or bitwise `exclusive or' operator
  2505.  
  2506. 
  2507. File: gpc.info,  Node: Support,  Next: To Do,  Prev: Keywords,  Up: Top
  2508.  
  2509. Where to get support for GNU Pascal; how to report bugs.
  2510. ********************************************************
  2511.  
  2512.    Here you can find information on where to find the most up-to-date
  2513. information about GPC, how you can get support (professional or
  2514. voluntary), how to use GPC's Test Suite, and how to report new bugs you
  2515. might encounter.
  2516.  
  2517.    If you have problems with GNU Pascal, please read the relevant
  2518. sections of the GPC Manual. The most current version of the manual is
  2519. available at
  2520. `http://agnes.dida.physik.uni-essen.de/~gnu-pascal/gpc-doc.html' for
  2521. online browsing.  You can also download the complete manual in HTML
  2522. format (tar.gz) (`gpc-html.tar.gz' on GPC's WWW home page).  The manual
  2523. is also available in DVI format (gzipped) (`gpc.dvi.gz' on GPC's WWW
  2524. home page) and PostScript format (gzipped) (`gpc.ps.gz' on GPC's WWW
  2525. home page) for printing.
  2526.  
  2527.    If the manual doesn't help you, here is what we recommend you to do:
  2528.  
  2529. *Note FAQ::                Check the GPC FAQ
  2530.  
  2531. * Menu:
  2532.  
  2533. * Mailing List::           Join the GPC Mailing List
  2534. * Mailing List Archives::  Look in the Mailing List Archives
  2535. * Newsgroups::             Ask in a newsgroup
  2536. * Professional Support::   Get individual support for GPC
  2537. * Compiler Crashes::       If the compiler crashes...
  2538. * Reporting Bugs::         Find out how to report GPC bugs
  2539. * Testing::                If you have GPC sources, learn how to run
  2540.                            the Test Suite to test your bugs reported
  2541.  
  2542. 
  2543. File: gpc.info,  Node: Mailing List,  Next: Mailing List Archives,  Up: Support
  2544.  
  2545. The GPC Mailing List
  2546. ====================
  2547.  
  2548.    There is a mailing list devoted to GNU Pascal. You can write to the
  2549. mailing list, e.g. if you have problems installing GPC or if you found
  2550. a problem with GPC (please see *Note Reporting Bugs::). You can also
  2551. use it to discuss suggestions for improving GPC and, most welcome, to
  2552. offer your help or contribute code, documentation or other work. Mails
  2553. to the list should be in English.
  2554.  
  2555.    To subscribe to the mailing list, send the command
  2556.      subscribe gpc your@email.address
  2557.    in the body of a mail to <majordomo@gnu.de> (*not* to
  2558. `gpc@gnu.de'!). The subject is ignored. (Please replace
  2559. `your@email.address' with your real email address.) For more info, send
  2560. a line `help' to <majordomo@gnu.de>.
  2561.  
  2562.    You can send a message to the mailing list by sending email to the
  2563. list address <gpc@gnu.de> as if it were a person.
  2564.  
  2565.    To leave the mailing list, send the command
  2566.      unsubscribe gpc your@email.address
  2567.    to <majordomo@gnu.de>.
  2568.  
  2569.    There is also a (low-traffic) announce list, <gpc-announce@gnu.de>
  2570. that you can subscribe to stay up-to-date. To subscribe to the list,
  2571. write an email with
  2572.      subscribe gpc-announce your@email.address
  2573.    in the body to <majordomo@gnu.de>. If you like to announce a
  2574. contribution, a service or an event related to GPC, you are invited to
  2575. post to this list rather than `gpc@gnu.de', but please don't use the
  2576. announce list for questions or discussions. Please note that all mail
  2577. sent to the announce list is forwarded to the regular list, so you
  2578. won't have to subscribe to both lists if you don't want to miss
  2579. anything.
  2580.  
  2581.